/*  
*********************************************************************************************************  
*                                                uC/OS-II  
*                                          The Real-Time Kernel  
*                                             TIME MANAGEMENT  
*  
*                          (c) Copyright 1992-2005, Jean J. Labrosse, Weston, FL  
*                                           All Rights Reserved  
*  
* File    : OS_TIME.C  
* By      : Jean J. Labrosse  
* Version : V2.80  
*********************************************************************************************************  
*/   
   
#ifndef  OS_MASTER_FILE   
#include "ucos_ii.h"   
#endif   
   
/*  
*********************************************************************************************************  
*                                DELAY TASK 'n' TICKS   (n from 0 to 65535)  
*  
* Description: This function is called to delay execution of the currently running task until the  
*              specified number of system ticks expires.  This, of course, directly equates to delaying  
*              the current task for some time to expire.  No delay will result If the specified delay is  
*              0.  If the specified delay is greater than 0 then, a context switch will result.  
*  
* Arguments  : ticks     is the time delay that the task will be suspended in number of clock 'ticks'.  
*                        Note that by specifying 0, the task will not be delayed.  
*  
* Returns    : none  
*********************************************************************************************************  
*/   
   
void  OSTimeDly (INT16U ticks)   
{   
    INT8U      y;   
#if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */   
    OS_CPU_SR  cpu_sr = 0;   
#endif   
   
   
   
    if (ticks > 0) {                             /* 0 means no delay!                                  */   
        OS_ENTER_CRITICAL();   
        y            =  OSTCBCur->OSTCBY;        /* Delay current task                                 */   
        OSRdyTbl[y] &= ~OSTCBCur->OSTCBBitX;   
        if (OSRdyTbl[y] == 0) {   
            OSRdyGrp &= ~OSTCBCur->OSTCBBitY;   
        }   
        OSTCBCur->OSTCBDly = ticks;              /* Load ticks in TCB                                  */   
        OS_EXIT_CRITICAL();   
        OS_Sched();                              /* Find next task to run!                             */   
    }   
}   
/*$PAGE*/   
/*  
*********************************************************************************************************  
*                                     DELAY TASK FOR SPECIFIED TIME  
*  
* Description: This function is called to delay execution of the currently running task until some time  
*              expires.  This call allows you to specify the delay time in HOURS, MINUTES, SECONDS and  
*              MILLISECONDS instead of ticks.  
*  
* Arguments  : hours     specifies the number of hours that the task will be delayed (max. is 255)  
*              minutes   specifies the number of minutes (max. 59)  
*              seconds   specifies the number of seconds (max. 59)  
*              milli     specifies the number of milliseconds (max. 999)  
*  
* Returns    : OS_NO_ERR  
*              OS_TIME_INVALID_MINUTES  
*              OS_TIME_INVALID_SECONDS  
*              OS_TIME_INVALID_MS  
*              OS_TIME_ZERO_DLY  
*  
* Note(s)    : The resolution on the milliseconds depends on the tick rate.  For example, you can't do  
*              a 10 mS delay if the ticker interrupts every 100 mS.  In this case, the delay would be  
*              set to 0.  The actual delay is rounded to the nearest tick.  
*********************************************************************************************************  
*/   
   
#if OS_TIME_DLY_HMSM_EN > 0   
INT8U  OSTimeDlyHMSM (INT8U hours, INT8U minutes, INT8U seconds, INT16U milli)   
{   
    INT32U ticks;   
    INT16U loops;   
   
   
#if OS_ARG_CHK_EN > 0   
    if (hours == 0) {   
        if (minutes == 0) {   
            if (seconds == 0) {   
                if (milli == 0) {   
                    return (OS_TIME_ZERO_DLY);   
                }   
            }   
        }   
    }   
    if (minutes > 59) {   
        return (OS_TIME_INVALID_MINUTES);        /* Validate arguments to be within range              */   
    }   
    if (seconds > 59) {   
        return (OS_TIME_INVALID_SECONDS);   
    }   
    if (milli > 999) {   
        return (OS_TIME_INVALID_MILLI);   
    }   
#endif   
                                                 /* Compute the total number of clock ticks required.. */   
                                                 /* .. (rounded to the nearest tick)                   */   
    ticks = ((INT32U)hours * 3600L + (INT32U)minutes * 60L + (INT32U)seconds) * OS_TICKS_PER_SEC   
          + OS_TICKS_PER_SEC * ((INT32U)milli + 500L / OS_TICKS_PER_SEC) / 1000L;   
    loops = (INT16U)(ticks / 65536L);            /* Compute the integral number of 65536 tick delays   */   
    ticks = ticks % 65536L;                      /* Obtain  the fractional number of ticks             */   
    OSTimeDly((INT16U)ticks);   
    while (loops > 0) {   
        OSTimeDly((INT16U)32768u);   
        OSTimeDly((INT16U)32768u);   
        loops--;   
    }   
    return (OS_NO_ERR);   
}   
#endif   
/*$PAGE*/   
/*  
*********************************************************************************************************  
*                                         RESUME A DELAYED TASK  
*  
* Description: This function is used resume a task that has been delayed through a call to either  
*              OSTimeDly() or OSTimeDlyHMSM().  Note that you can call this function to resume a  
*              task that is waiting for an event with timeout.  This would make the task look  
*              like a timeout occurred.  
*  
*              Also, you cannot resume a task that has called OSTimeDlyHMSM() with a combined time that  
*              exceeds 65535 clock ticks.  In other words, if the clock tick runs at 100 Hz then, you will  
*              not be able to resume a delayed task that called OSTimeDlyHMSM(0, 10, 55, 350) or higher:  
*  
*                  (10 Minutes * 60 + 55 Seconds + 0.35) * 100 ticks/second.  
*  
* Arguments  : prio                      specifies the priority of the task to resume  
*  
* Returns    : OS_NO_ERR                 Task has been resumed  
*              OS_PRIO_INVALID           if the priority you specify is higher that the maximum allowed  
*                                        (i.e. >= OS_LOWEST_PRIO)  
*              OS_TIME_NOT_DLY           Task is not waiting for time to expire  
*              OS_TASK_NOT_EXIST         The desired task has not been created or has been assigned to a Mutex.  
*********************************************************************************************************  
*/   
   
#if OS_TIME_DLY_RESUME_EN > 0   
INT8U  OSTimeDlyResume (INT8U prio)   
{   
    OS_TCB    *ptcb;   
#if OS_CRITICAL_METHOD == 3                                    /* Storage for CPU status register      */   
    OS_CPU_SR  cpu_sr = 0;   
#endif   
   
   
   
    if (prio >= OS_LOWEST_PRIO) {   
        return (OS_PRIO_INVALID);   
    }   
    OS_ENTER_CRITICAL();   
    ptcb = OSTCBPrioTbl[prio];                                 /* Make sure that task exist            */   
    if (ptcb == (OS_TCB *)0) {   
        OS_EXIT_CRITICAL();   
        return (OS_TASK_NOT_EXIST);                            /* The task does not exist              */   
    }   
    if (ptcb == (OS_TCB *)1) {   
        OS_EXIT_CRITICAL();   
        return (OS_TASK_NOT_EXIST);                            /* The task does not exist              */   
    }   
    if (ptcb->OSTCBDly == 0) {                                 /* See if task is delayed               */   
        OS_EXIT_CRITICAL();   
        return (OS_TIME_NOT_DLY);                              /* Indicate that task was not delayed   */   
    }   
   
    ptcb->OSTCBDly = 0;                                        /* Clear the time delay                 */   
    if ((ptcb->OSTCBStat & OS_STAT_PEND_ANY) != OS_STAT_RDY) {   
        ptcb->OSTCBStat   &= ~OS_STAT_PEND_ANY;                /* Yes, Clear status flag               */   
        ptcb->OSTCBPendTO  = TRUE;                             /* Indicate PEND timeout                */   
    } else {   
        ptcb->OSTCBPendTO  = FALSE;   
    }   
    if ((ptcb->OSTCBStat & OS_STAT_SUSPEND) == OS_STAT_RDY) {  /* Is task suspended?                   */   
        OSRdyGrp               |= ptcb->OSTCBBitY;             /* No,  Make ready                      */   
        OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;   
        OS_EXIT_CRITICAL();   
        OS_Sched();                                           /* See if this is new highest priority   */   
    } else {   
        OS_EXIT_CRITICAL();                                   /* Task may be suspended                 */   
    }   
    return (OS_NO_ERR);   
}   
#endif   
/*$PAGE*/   
/*  
*********************************************************************************************************  
*                                         GET CURRENT SYSTEM TIME  
*  
* Description: This function is used by your application to obtain the current value of the 32-bit  
*              counter which keeps track of the number of clock ticks.  
*  
* Arguments  : none  
*  
* Returns    : The current value of OSTime  
*********************************************************************************************************  
*/   
   
#if OS_TIME_GET_SET_EN > 0   
INT32U  OSTimeGet (void)   
{   
    INT32U     ticks;   
#if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */   
    OS_CPU_SR  cpu_sr = 0;   
#endif   
   
   
   
    OS_ENTER_CRITICAL();   
    ticks = OSTime;   
    OS_EXIT_CRITICAL();   
    return (ticks);   
}   
#endif   
   
/*  
*********************************************************************************************************  
*                                            SET SYSTEM CLOCK  
*  
* Description: This function sets the 32-bit counter which keeps track of the number of clock ticks.  
*  
* Arguments  : ticks      specifies the new value that OSTime needs to take.  
*  
* Returns    : none  
*********************************************************************************************************  
*/   
   
#if OS_TIME_GET_SET_EN > 0   
void  OSTimeSet (INT32U ticks)   
{   
#if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */   
    OS_CPU_SR  cpu_sr = 0;   
#endif   
   
   
   
    OS_ENTER_CRITICAL();   
    OSTime = ticks;   
    OS_EXIT_CRITICAL();   
}   
#endif   

